#!/bin/python3

"""
1. 请写出列表支持的所有方法及说明（例如: append 向列表末尾添加元素）

print(dir(list))

append(): 在列表末尾添加一个元素
x=[1,2,3,4]
x.append(5)
print(x)

clear(): 删除列表中的所有元素
x=[1,2,3,4]
x.clear()
print(x)

copy(): 生成一个新列表,复制列表中所有的元素
x=[1,3,4]
y=x.copy()
print(y)

count(): 统计列表中value元素出现的次数
x=[1,23,4,2,5,4]
count=x.count(4)
print(count)

extend(): 在列表末尾添加多个元素。
x=['a','12',[1,2,3],(1,3)]
y=['a',{23,24},{'asd':213,'f':2}]
x.extend(y)
print(x)

index(): 列表中第一次出现元素的位置
y=['a',{23,24},{'asd':213,'f':2},4]
a=y.index(4)
print(a)

insert(): 在列表索引位置，插入元素
y=['a',{23,24},{'asd':213,'f':2},4]
y.insert(3,'a')
print(y)

pop(): 弹出列表中第index个元素并取出,从列表中删除,默认弹出列表最后一个元素
y=['a',{23,24},{'asd':213,'f':2},4]
y.pop()
print(y)

remove(): 将列表中出现的第一个元素value删除
y=['a',{23,24},{'asd':213,'f':2},4]
y.remove(y[2])
print(y)

reverse(): 将列表中的元素倒序
y=['a',{23,24},{'asd':213,'f':2},4]
y.reverse()
print(y)

sort(): 将原列表中的元素进行排序
y=['a',{23,24},{'asd':213,'f':2},4]
x=[12,3,4,5,1,5,2,6,8,12]
x.sort()
print(x)

len(): 返回列表中元素个数
y=['a',{23,24},{'asd':213,'f':2},4]
print(len(y))
"""


"""
2. 说明列表的浅拷贝和深拷贝的区别
list1 = [4,5,[1,2,3],6]
x=list1.copy()
print(x)
print(list1)
list1[2][0] = 11
print(x)
print(list1)
x[2][1]==22
print(x)
print(list1)

浅拷贝创建了一个对象，该对象具有与原始对象相同的值。当原始对象包含引用类型(如数组、对象等)时，浅拷贝将只复制引用，而不复制引用指向的对象。这意味着，如果原始对象中的某个引用类型的内容发生变化时，浅拷贝后的对象中相应部分也会发生变化，因为他们引用的仍然是同一份数据。

import copy
list1 = [4,5,[1,2,3],6]
deep_copy=copy.deepcopy(list1)
print(list1)
print(deep_copy)
list1[2][1]=22
print(list1)
print(deep_copy)
deep_copy[2][2]=33
print(list1)
print(deep_copy)

深拷贝则是创建一个新的对象，同时递归复制原始对象中所有的引用类型及其包含的对象，因此，当原对象的引用对象发生变化时，深拷贝后的对象不会改变。
"""

"""
3. 说明列表和元组的相同点和不同点

相同点（都是线性表）
1、列表和元组都可以存储多个元素
2、列表和元组都可以通过索引访问元素
3、列表和元组都可以使用切片操作获取子序
4、列表和元组都可以使用迭代来遍历元素

不同点
1、列表是可变的，即可以增加、删除、修改元素；而元组不可变，不能增加元素，不能删除元素，不能更新元素
2、列表使用[]来表示，元素之间用,分割；元素使用()来表示，元素之间用,来分割
3、列表的长度可以动态改表；元组的长度是固定的
4、列表的操作和方法较多，包括排序、反转、添加、删除等；元组的操作和方法较少，主要包括索引和切片操作
5、列表通常用于存储同类型的数据，元组通常用于存储不同类型的数据，或者用于表示一个不可变的数据结构，如坐标、日期等。

x=(1,2)
x.update(2,3)
print(x)
"""

"""
4. 请写出字符串支持的所有方法及说明（例如: lower 返回字符串的小写）
x=dir(str)
print(x)

capitalize(): 将字符串的第一个字母变成大写，其余字母变为小写
str="i Love python".capitalize()
print(str)

title(): 返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余因为字母小写
str="i am very love python".title()
print(str)

swapcase(): 将字符串str中的大小写字母同时进行互换，即将字符串str中的大写字母转换为小写字母，将小写字母转化为大写字母
x="I Am Love PYTHON".swapcase()
print(x)

lower(): 将字符串中的所有大写字母转化为小写字母。
x="我爱pythoN Python!".lower()
print(x)

upper(): 将字符串中的所有小写字母转化为大写字母
x="i am very love python".upper()
print(x)

casefold(): 将字符串中的所有大写字母转换为小写字母，也可以将非英文语言中的大写转换为小写
x="Groβ - α".casefold
print(x)
y='I am verY lovce python'.casefold()
print(y)

center(): 返回一个长度为width,两边用fillchar（单字符）填充的字符串，即字符串str居中，两边用fillchar填充，若字符串的长度大于width，则直接返回字符串str。
x='shuai'.center(10,'*')
print(x)

ljust(): 返回一个原字符串左对齐，并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
x='shuai'.ljust(10,"*")
print(x)
L=["jack","bob","carl"]
for name in L:
	print(name.ljust(10,'#'))

rjust(): 返回一个原字符串右对齐，并使用fillchar填充（默认为空格）至指定长度的新字符串，如果指定的长度小于原字符串的长度则直接返回原字符串
L=["jack","bob","carl"]
for name in L:
    print(name.rjust(10,'#'))

zfill(): 返回指定长度的字符串，使原字符串右对齐，前面用0填充到指定字符串长度
L=["jack","bob","carl"]
for name in L:
    print(name.zfill(10))
L=["jack","bob","carl"]
print([name.zfill(10) for name in L])

encode(): 以指定的编码格式编码字符串，默认编码为'utf-8'。encode英文原意 编码
str1="我爱祖国".encode(encoding="utf8",errors="strict")
print(str1)
str2="I love my country".encode(encoding="utf8",errors="strict")
print(str2)

decode(): 以encoding指定的编码格式解码字符串，默认编码为字符串编码。decode英文意思是解码
str1="我爱学习".encode(encoding='utf-8')
print(str1)
str2=str1.decode(encoding='utf8')
print(str2)

find(): 查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回-1
x="I love python".find("o")
print(x)

rfind(): 查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串中的索引查找范围。若无则返回-1.
str1="I love python".rfind('o',4,12)
print(str1)

index(): 查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围(start,end)
str1="I love python".index('o',4)
print(str1)

rindex(): rindex()方法返回子字符串最后一次出现在字符串的索引位置，该方法与rfind()方法一样，可以规定字符串的索引
查找范围(start,end),只不过如果子字符串不在字符串中会报一个异常
str1="I love python".rindex('o',4)
print(str1)

format(): 格式化字符串的函数str.format()
print('{0},{1} and {2}'.format('gao','gap','year'))
print(['f_{}'.format(r) for r in list('abcd')])

format_map(): 返回字符串的格式化版本。在Python3中使用format和format_map方法都可以进行字符串格式化，但format是一种所有
情况都能使用的格式化方法，format_map仅使用于字符串格式中可变数据参数来源于字典等映射关系数据时才可以使用。
student={'name':'张三','class':'20230504','score':748}
print('{class}班级{name}总分: {score}'.format_map(student))

endswith(): 判断字符串是否以指定字符或子字符串结尾
str1="I love python".endswith('n')
print(str1)
file="python.txt"
if file.endswith("txt"):
	print('该文件是文本文件')
elif file.endswith('AVI','WMV','RM'):
	print('该文件是视频文件')
else:
	print('文件格式未知')

startswith(): 判断字符串是否以指定字符或子字符串开头
print("hello,i love python".startswith('h'))

isalnum(): 检测字符串是否由字母和数字组成，str中至少有一个字符且所有字符都是字母或数字则返回True，否则返回false
print('seven-11'.isalnum())

isalpha(): 检测字符串是否只由字母组成，字符串中至少有一个字符且所有字符都是字母则返回True，否则返回False
print('i love python'.isalpha())
print('ilovepython'.isalpha())

isdecimal(): 检查字符串是否只包含十进制字符，字符串中若只包含十进制字符返回True，否则返回False，该方法只存在鱼unicode对象中，
注意：定义一个十进制字符串，只需要在字符串前添加前缀'u'即可。
print('1234'.isdecimal())

isdigit(): 检测字符串是否只由数字组成，字符串中至少有一个字符且所有字符都是数字则返回True，否则返回False
print('123'.isdigit())

isidentifier(): 判断str是否是有效的标识符。str为符合命名规则的变量，保留标识符则返回True,否者返回False。
print('123'.isidentifier())
print('_123'.isidentifier())

islower(): 检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。
print('i love python'.islower())

isupper(): 检测字符串中的字母是否全由大写字母组成。（字符串中可包含非字母字符）。字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是大写，则返回 True，否则返回 False。
print('I LOVE PYTHON'.isupper())

isnumeric(): 测字符串是否只由数字组成。这种方法是只适用于unicode对象。字符串中只包含数字字符，则返回 True，否则返回 False
print(u'12345'.isnumeric())
print(u'1123das2345'.isnumeric())

isprintable(): 判断字符串中是否有打印后不可见的内容。如：\n \t 等字符。若字符串中不存在\n \t 等不可见的内容，则返回True,否者返回False。
print('i love python'.isprintable())
print('i love\t python'.isprintable())

isspace(): 检测字符串是否只由空格组成。若字符串中只包含空格，则返回 True，否则返回 False。
str1=' '
str2='i lovce python'
print(str1.isspace())
print(str2.isspace())

istitle(): 检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False.
print('i love python'.istitle())

strip(): 该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符
a=' \n111 aaa '
print(a.strip())
b='.-.word:我很帅.-.'
print(b.strip('.-.'))

lstrip(): lstrip() 方法用于截掉字符串左边的空格或指定字符。
a='--我爱python--'
print(a.lstrip('-'))

rstrip(): 删除字符串末尾的指定字符（默认为空格）
a='123532423-1231'
print(a.rstrip('-1231'))

maketrans(): 制作翻译表，删除表，常与translate()函数连用。 即：返回用于str.translate方法翻译的转换表。
in_str='dasfga'
out_str='123212'
map_table=str.maketrans(in_str,out_str)
print(map_table)

translate(): 过滤(删除)，翻译字符串。即根据maketrans()函数给出的字符映射转换表来转换字符串中的字符。
my_love='I love fairy'
print(my_love.translate(map_table))

partition(): 根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。
str1='http://www.google.com/'
#print(str1.partition('://'))
#print(str1.partition(','))
#print(str1.partition('.'))
print(type(str1.partition('://')))

rpartition(): 根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。
str1='https://www.google.com/'
print(str1.rpartition('.'))

split(): 拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。
str1='I love python'
print(str1.split()[2])

rsplit(): 拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表,类似于split()函数，只不过 rsplit()函数是从字符串右边(末尾)开始分割。
str1='abcxyzopq'.partition('xy')
print(str1)
print('abcxyzopq'.rpartition('xy'))
print('abcxyzopq'.rsplit('xy'))

splitlines(): 按照('\n', '\r', \r\n'等)分隔，返回一个包含各行作为元素的列表，默认不包含换行符。\n 换行符 \r 回车符 \r\n 回车+换行
print('HOW\nSOFT\nWORKSs'.splitlines()[2])
print('HOW\SOFT\nWORKSs'.splitlines())

join(): 将iterable变量的每一个元素后增加一个str字符串。
L='python'
print('_'.join(L))
L3={'name':"malongshuai",'gender':'male','from':'China','age':18}
print('_'.join(L3))

replace(): 把str.中的 old 替换成 new,如果 count 指定，则替换不超过 count次.。
s="我的小伙伴张三"
print(s.replace("张三","马云"))

expandtabs(): 将字符串S中的 \t 替换为一定数量的空格。默认N=8。
print('01\t012\t0123\t01234'.expandtabs(3))

count(): 统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置
"""
print('abc--qo0ab--ab'.count('ab'))
print('abc--qo0ab--ab'.count('ab',1))
print('abc--qo0ab--ab'.count('ab',1,10))










5. 有如下一个字符串变量logs，请统计出每种请求类型的数量（提示：空格分割的第2列是请求类型），得到如下输出：
POST 2
GET 3

下边是logs变量：
"""
logs = '''
111.30.144.7 "POST /mock/login/?t=GET HTTP/1.1" 200 
111.30.144.7 "Get /mock/users/?t=POST HTTP/1.1" 200 
111.13.100.92 "Post /mock/login/ HTTP/1.1" 200 
223.88.60.88 "GET /mock/users/?t=POST HTTP/1.1" 200 
111.30.144.7 "GET /mock/users/ HTTP/1.1" 200 
'''

count_post=0
count_get=0
for line in logs.strip().splitlines():
	request_type=line.split('"')[1].split()[0].upper()
	if request_type == 'POST':
		count_post += 1
	elif request_type == 'GET':
		count_get += 1
print('{} {}'.format('POST',count_post))
print('{} {}'.format('GET',count_get))

